The middle of the workshop deck shifts from prompting into agent behavior. It distinguishes passive knowledge from active autonomy, shows how Ask/Edit/Agent/Plan modes change the risk profile of a task, and outlines how Claude Code sessions should be structured before developers hand over execution.
The deck spends real time on this because teams routinely blur the two. A skill file gives the model domain expertise. An agent reasons, calls tools, inspects results, retries, and decides what to do next.
CLAUDE.md, SKILL.md, or project instruction files.Both Copilot and Claude Code support multiple ways of working. The deck’s recommendation is to start with lower-autonomy modes when the task is simple and switch up only when scope, uncertainty, or execution needs justify it.
Q&A, explanation, architecture understanding, and lightweight exploration. No files change. This is the cheapest place to clarify intent before you risk code churn.
You choose the file set and the AI proposes diffs inside that boundary. This is the workshop’s controlled middle ground for refactors, renames, and contained changes.
The model decides what to inspect and modify, runs tools, and loops until it believes the job is complete. Powerful, but only safe when the task and constraints are already clear.
Think first, then execute. The deck repeatedly treats planning mode as the default starting point for multi-file work because it exposes file impact, edge cases, and risk before edits begin.
If the change crosses files, tests, or migrations, start in plan mode even when the implementation feels obvious. The extra minute up front is usually cheaper than unwinding a confident wrong diff.
One of the strongest pages in the deck is the skill-file ecosystem diagram. It separates always-on instructions from demand-loaded expertise so the model gets the right knowledge at the right time without carrying unnecessary weight every turn.
CLAUDE.mdProject-wide Claude Code instructions. The deck’s guidance is to keep it tight because it loads every turn and therefore costs tokens every turn.
/skills/*/SKILL.mdDomain-specific expertise such as auth, billing, or release patterns. Skills are where detailed conventions belong once they stop being universal.
.claude/agents/*.mdCustom subagents with specific tools or roles. The workshop positions these as a way to standardize specialized workers rather than keep reteaching the same behavior.
AGENTS.mdCross-agent coordination instructions that can keep Claude, Copilot, and other agent runtimes aligned on team standards.
.github/copilot-instructions.mdCopilot-specific project guidance, with optional custom agents under .github/agents when the team wants more structured behavior inside GitHub tooling.
The deck’s practical guidance is simple: system prompts should stay compact, skills should hold depth. That split keeps always-loaded context lean while preserving detailed domain knowledge when an agent actually needs it.
The workshop’s Claude Code section is intentionally operational. It walks through how to start a session, describe a task, force a plan, execute, then review and compact before moving on.
Open Claude Code at the project root so it can read CLAUDE.md, discover available skills, and start with the right repository context.
Use plain English, but keep it specific. Files, errors, constraints, and desired outcomes matter more than polished prose.
Use --plan or explicitly ask for a plan first. Review touched files, edge cases, and what the agent says it will not change.
Only after the plan is approved should the agent read, write, test, and call tools in a loop. The deck treats this as a governed handoff, not blind trust.
Check the diff, inspect test results, and compact or reset before the next task so stale assumptions do not leak across sessions.
They work in a hub-and-spoke model: focused workers with separate context windows that report back to a parent session. The deck recommends them for exploration, test runs, and code review.
The deck positions agent teams as a more expensive option for full-stack features and complex parallel reviews where workers need to coordinate directly instead of reporting only to a parent.